home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / viewers / polyview / polyvw31.lha / Polyview3.1 / new / pvmsg.c < prev    next >
C/C++ Source or Header  |  1993-06-23  |  7KB  |  182 lines
  1. /*****************************************************************************
  2.  * NCSA Polyview 3.0                                                         *
  3.  *                                                                           *
  4.  * Version 3 changes and additions by Marc Andreessen.                       *
  5.  * Version 2 by Brian Calvert.                                               *
  6.  *                                                                           *
  7.  * Software Development Group                                                *
  8.  * National Center for Supercomputing Applications                           *
  9.  * University of Illinois at Urbana-Champaign                                *
  10.  *                                                                           *
  11.  * This is BETA release software.  As such it may contain software bugs and  *
  12.  * exhibit inconsistencies.                                                  *
  13.  *                                                                           *
  14.  * Please send bug reports to polyview@ncsa.uiuc.edu.                        *
  15.  *                                                                           *
  16.  * Copyright (c) 1992 The Board of Trustees of the University of Illinois.   *
  17.  *                                                                           *
  18.  * Permission to use, copy, and modify this software and its                 *
  19.  * documentation for educational, research, and non-profit purposes is       *
  20.  * hereby granted, provided that the above copyright notice, the original    *
  21.  * authors names, and this permission notice appear in all such copies.      *
  22.  * Any distribution of this software requires the explicit and written       *
  23.  * authorization of the authors.                                             *
  24.  *                                                                           *
  25.  * The University of Illinois makes no representations about the             *
  26.  * suitability of this software for any purpose.  It is provided "as is"     *
  27.  * without warranty of any kind.                                             *
  28.  *****************************************************************************/
  29.  
  30. /* $Header: /usr3/people/gbourhis/pv3/new/RCS/pvmsg.c,v 1.1 92/09/18 10:55:26 marca Exp $ */
  31.  
  32. #ifdef RCSLOG
  33. $Log:    pvmsg.c,v $
  34.  * Revision 1.1  92/09/18  10:55:26  marca
  35.  * Initial revision
  36.  * 
  37. #endif
  38.  
  39. #include "pv.h"
  40.  
  41. /* OVERVIEW 
  42.  
  43.   "Messages" are an abstraction used to encapsulate inter-window
  44.   communication.  Messages notify chosen sets of windows of a change in
  45.   the state of the program that could affect them.  Typically this
  46.   occurs when the user performs some type of action, although messages
  47.   may also be triggered by timer events or changes in resource
  48.   availablity.
  49.   
  50.   IMPLEMENTATION Messages are implemented via function pointers
  51.   associated with each window.  These function pointers refer to
  52.   message-handling functions which parse the message and act on it, if
  53.   necessary.  Each notify function is assumed to use the following list
  54.   of arguments:
  55.   
  56.   int notify_fn(state_t * state, window_t * send_win,
  57.   window_t * recv_win, int message, ...)
  58.   
  59.   The send_win is the window which originated the message (this is NULL
  60.   if irrelevant or if the system itself generated it).  The recv_win is
  61.   the window whose notify_fn is being executed.  The message value
  62.   determines how the notify function should interpret the arguments
  63.   which follow.
  64.   
  65.   There is no reason the message-passing could not be implemented via
  66.   sockets or other inter-process or inter-machine connection media. */
  67.  
  68.  
  69. /* broadcast message sends the message and its parameters to all of the */
  70. /* windows.  It sends the message to itself last of all, so that changes */
  71. /* will wait until all windows have been notified.  Returns ST_OKAY if no */
  72. /* errors occur. */
  73. int broadcast_msg(state_t * state, window_t * send_win, int msg, ...)
  74. {
  75.   window_t *w;
  76.   va_list args;
  77.     
  78.   /* Initlialize args to the beginning of the list. */
  79.   va_start(args, msg);
  80.   
  81.   /* Pass the message to all other windows in the system. */
  82.   FOR_ALL_WINDOWS(state, w) 
  83.     {
  84.       if (w != send_win) 
  85.         {
  86.           /* If the notify function is NULL, it just means that */
  87.           /* window does not want messages. */
  88.           if (WIN_NOTIFY_FN(w) != NULL)
  89.             WIN_NOTIFY(w)(state, send_win, w, msg, args);
  90.         }
  91.     }
  92.   
  93.   /* Send the message to the originating window. */
  94.   if ((send_win != NULL) && (WIN_NOTIFY_FN(send_win) != NULL))
  95.     WIN_NOTIFY(send_win)(state, send_win, send_win, msg, args);
  96.   
  97.   va_end(args);
  98.   return ST_OKAY;
  99. }
  100.  
  101.  
  102. /* send message to id sends the message and its parameters to the window */
  103. /* with the given id value.  Returns ST_ERROR if there is no window with */
  104. /* a matching id value, ST_OKAY otherwise. */
  105. int send_msg_to_id(state_t * state, window_t * send_win, int id, int msg, ...)
  106. {
  107.   window_t *w;
  108.   va_list args;
  109.     
  110.   /* Pass the message to the window. */
  111.   w = find_window_by_id(state, id);
  112.   
  113.   if (w != NULL) 
  114.     {
  115.       va_start(args, msg);
  116.       send_msg_to_win(state, send_win, w, msg, args);
  117.       va_end(args);
  118.       return ST_OKAY;
  119.     }
  120.   else 
  121.     {
  122.       return ST_ERROR;
  123.     }
  124. }
  125.  
  126.  
  127. /* send message to type sends the message and its parameters to all windows */
  128. /* with the given type.  Returns the number of windows which were notified, */
  129. /* -1 if an error occurs. */
  130. int send_msg_to_type(state_t * state, window_t * send_win, int type, 
  131.                      int msg, ...)
  132. {
  133.   int matches;
  134.   window_t *w;
  135.   va_list args;
  136.     
  137.   /* Initlialize args to the beginning of the list. */
  138.   va_start(args, msg);
  139.   
  140.   /* Pass the message to every window in the system. */
  141.   matches = 0;
  142.   FOR_ALL_WINDOWS(state, w) 
  143.     {
  144.       if (WIN_TYPE(w) == type) 
  145.         {
  146.           matches++;
  147.           send_msg_to_win(state, send_win, w, msg, args);
  148.         }
  149.     }
  150.   
  151.   va_end(args);
  152.   return matches;
  153. }
  154.  
  155.  
  156. /* send message to win sends the message and its parameters to the given */
  157. /* window.  Returns ST_ERROR if the window is illegal, ST_OKAY otherwise. */
  158. int send_msg_to_win(state_t * state, window_t * send_win, window_t * recv_win,
  159.                     int msg, ...)
  160. {
  161.   va_list args;
  162.     
  163.   /* If the window pointer is NULL, we have an error. */
  164.   if (recv_win == NULL) 
  165.     {
  166.       return ST_ERROR;
  167.     }
  168.   else 
  169.     {
  170.       /* If the notify function is NULL, it just means that this */
  171.       /* window does not want messages. */
  172.       if (WIN_NOTIFY_FN(recv_win) != NULL) 
  173.         {
  174.           va_start(args, msg);
  175.           WIN_NOTIFY(recv_win)(state, send_win, recv_win, msg,
  176.                                args);
  177.           va_end(args);
  178.         }
  179.     }
  180.   return ST_OKAY;
  181. }
  182.